from collections import deque

dy =[1,-1,0,0] ; dx=[0,0,-1,1]         
def solution(places):
    answer = []
    for place in places : 
        # 1. 응시자 위치 확인 
        people = []
        for i in range(5) :
            for j in range(5) :
                if place[i][j] == "P":
                    people.append([i,j])
        #2. 응시자 별로 거리 확인하기
        def bfs(start):
            clv = 0 
            visited = [[-1]*5 for _ in range(5)] # 거리 저장하기(lv)
            q = deque([start]) 
            visited[start[0]][start[1]] = 0 
            while q  :
                cy,cx = q.popleft()
                clv = visited[cy][cx]
                if clv >= 2 : 
                    break
                for d in range(4):
                    ny,nx = cy + dy[d] , cx +dx[d]
                    if 0<= ny < 5 and 0 <= nx < 5 and visited[ny][nx] <= -1  : 
                        if place[ny][nx] == "X": 
                            visited[ny][nx] = clv +1 
                            continue
                        elif place[ny][nx] == "O":
                            q.append([ny,nx])
                            visited[ny][nx] = clv +1 
                        elif place[ny][nx] == "P" :
                            return False 
            return True 
        flag = True
        for p in range(len(people)):
            start = people[p]
            flag = bfs(start) 
            if not flag : 
                break
        if flag: 
            answer.append(1)
        else :
            answer.append(0)
        
            
    # print(people)
    # print(f"answer{answer}")
    return answer

import sys
from collections import deque
input = sys.stdin.readline

n = int(input())
field = [] 
limit_list= set()
limit_list.add(0) 
# 1. 물에 잠김, 생존 구역으로 구분한 field 만들기
for i in range(n):
  tmp = list(map(int,input().split()))
  for j in range(n) :
    # limit_list 수집하기 = 노드의 높이 값 종류
    limit_list.add(tmp[j])
  field.append(tmp)
# print(f"field - {limit_list}")

# 종류별 limit에 따라 지대 높이가 limit 이하일 경우 침수되는 지역, 생존 지역 명시
# board :  생존 여부 + 방문 여부 확인 flag 역할
def init_board(limit) :
  # 각 limit 별로 침수되는 지역을 확인하기
  board = [[0 for _ in range(n)] for k in range(n)  ]
  saved_point = []
  # 침수 지역 맵 업데이트하기
  for i in range(n):
    for k in range(n):
      if field[i][k] <= limit : # 침수 지역
        board[i][k] =-1
      else : 
         # 생존 지역
        saved_point.append([i,k])
  return board,saved_point

# 2. 생존 구역들의 군집 개수 구하기 
#상하좌우
dy =[-1,1,0,0 ]
dx = [0,0,-1,1]
def bfs(sy,sx , field): 
  # (1)시작점 정의
  q = deque()
  q.append([sy,sx])
  field[sy][sx] = 1 # 방문 등록
  # (2)인접한 노드 
  while q  : 
    cy,cx =q.popleft()
    for dw in range(4):
      ny,nx = cy + dy[dw] , cx +dx[dw] 
      # 2-1 필드 범위에서 벗어나는지 확인
      # 2-2방문 여부 확인
      if 0<= ny < n and 0<= nx < n and field[ny][nx] == 0 : # 방문 안했으면 업데이트
        q.append([ny,nx])
        field[ny][nx] = 1 
    
  return 0 
# main 함수 
max_cnt = 0 
for limit in limit_list :  #limit 을 1개씩 조합해봄 
  board,saved_point = init_board(limit)
  # print(f"##{limit} : {saved_point}")
  cnt = 0 
  # 생존 구역에서 확인 
  for y,x in saved_point :
    if board[y][x] == 0 :#방문 안했으면 -> bfs 탐색 진행
      bfs(y,x, board)
      cnt +=1 

  max_cnt = max(max_cnt , cnt)
print(max_cnt)

import sys
input = sys.stdin.readline
# 1. 입력 변수 및 출력 형식에 맞춰 설정하기
while True :
  set_s = list(map(int, input().split()))
  answer = []
  if len(set_s) < 2 : 
    break 
  k= set_s.pop(0)
  #2. 유효성 검사 is_valid 정의
  # check = [True]*len(set_s[1:])
  result = [0]*6 # 출력 리스트
  #3. 백트래킹 함수 정의
  def conbination(level ,idx ): 
    #종료 조건
    if level == 6 : 
      answer.append(result.copy())
      # print(result)
      return 
    # 동작 과정
    for i in range(idx,k):
      result[level] = set_s[i]
      conbination(level+1 ,i+1) # 조합은 idx 보다 작은 i는 탐색 할 필요 없음
      result[level] = 0 
  conbination(0,0)
  # print(answer)
  # 3. 출력 형식 맞추기
  for a in answer: 
    print(" ".join(map(str,a)))
  print("")

import sys

#0. 입력 변수 정의 및 초기화 하기
input= sys.stdin.readline
N = int(input())
eggs = [[] for _ in range(N)]

for i in range(N):
  durability , weight =map(int ,input().split())
  eggs[i] = [durability , weight]

# 1. backtracking 수행하기
max_cnt = 0 
def backtracking(idx,cnt) :
  global max_cnt
  print(f"stage {idx}")
  # pruning 조건 : 현재 남은 횟수로 2개씩 깨도  max_cnt 업데이트 불가 경우
  if max_cnt >= (cnt + (N-idx)*2):
    
  #1. 종료 조건 : (1. 모든 계란 선택 완료 n == N)
  if idx >= N : # 1개 이하 남아있을떄 
    max_cnt = max(max_cnt , cnt)
    return 0 
  
  #1-2. 현재 선택한 계란 (idx) 가 깨져있는 경우
  if eggs[idx][0] <= 0 : 
    backtracking(idx+1 , cnt)
  #2.동작 과정- 계란 깨기
  else : # 현재 계란 lived -> 부딫힐 계란 선택 & 부딫치기
    flag =False
    for j in range(N) :#현재 계란 부딫칠 계란 선택 (본인idx 아님 or 생존 )
      if j!= idx and eggs[j][0] > 0 : 
        # 충돌
        eggs[idx] =eggs[idx] -eggs[j][1]
        eggs[j] =eggs[j] -eggs[idx][1]
        backtracking(idx+1 , cnt+int(eggs[idx][0]<=0) + int(eggs[j][0]<=0) ) # 충돌 계산하기
        flag = True
        # 충돌 원상 복귀
        eggs[idx] =eggs[idx] +eggs[j][1]
        eggs[j] =eggs[j] +eggs[idx][1]
    # 한 번도 안 깨짐 -> 선택한 idx 내려두고 다음 idx +1 로 이동  
    if not flag : 
      backtracking(idx+1 , cnt )

  return 0 

backtracking(0 ,0)
print(max_cnt)

import sys
input = sys.stdin.readline
# 0. 입력 변수 정의 및 초기화 하기
o = list(input())
l = list(input())
INF = 1000
if len(l) < len(o) :
  print(-1)
  exit()
#1. dp 정의
# dp[i][j][0] : de[i][j]로 O[:i] == L[:j]
dp = [[[0,0] for j in range(len(l)+1)] for i in range(len(o)+1)]
# 초기화
dp[0][0] = [0,INF]
for j in range(1,len(l)+1):
  dp[0][j][1] = 1 
  dp[0][j][0] = INF 
# for i in range(len(o)+1):
#   dp[i][0][0] = -1 

# #2. 점화식 
for i in range(len(o)) :
  for j in range(i+1):
    dp[i+1][j][0] = dp[i+1][j][1] = INF
  for j in range(i, len(l)):
    if o[i] == l[j] :
      dp[i+1][j+1][0] = min(dp[i][j][0] , dp[i][j][1])
    else : 
      dp[i+1][j+1][0] = INF 
    dp[i+1][j+1][1] = min(dp[i+1][j][0] +1 , dp[i+1][j][1])
#3. 출력
if min(dp[-1][-1][0],dp[-1][-1][1]) >= INF : 
  print(-1)
else :
  print(min(dp[-1][-1][0] , dp[-1][-1][1]))